package top.i89ck.modules.service;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import com.jfinal.kit.Kv;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.SqlPara;
import top.i89ck.common.tree.TreeUtils;
import top.i89ck.modules.model.Dict;

import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.StrUtil;

/**
 * 字典数据。
 *
 * @author Seiya
 */
public class DictService {

    /**
     * 通过字典的类型， 查询当前类型名下的下级的字典数据
     *
     * @param type
     * @return
     */
    public List<Dict> getSubList(String type) {
        Kv data = Kv.by("type", type.toUpperCase());
        SqlPara sqlPara = Db.getSqlPara("sysDict.getSubList", data);
        return Dict.dao.find(sqlPara);
    }

    /**
     * 通过字典的类型， 查询当前类型下级的字典数据， 并生成{key:value}格式的Map数据
     *
     * @param type
     * @return
     */
    public Map<String, String> getSubMap(String type) {
        List<Dict> dicts = getSubList(type);
        Map<String, String> map = new LinkedHashMap<>();
        for (Dict dict : dicts) {
            map.put(dict.getData(), dict.getName());
        }
        return map;
    }

    /**
     * 通过 字典类型 和 字典数据， 查询该类型下的唯一的一条字典信息。
     *
     * @param parentType 上级字典类型
     * @param data       当前字典数据
     * @return
     */
    public Dict getOne(String data, String parentType) {
        Kv kv = Kv.by("type", parentType).set("data", data);
        SqlPara sqlPara = Db.getSqlPara("sysDict.getSubOne", kv);
        return Dict.dao.findFirst(sqlPara);
    }

    /**
     * 通过字典类型，查询当前字典类型的唯一一条字典数据
     *
     * @param type 字典类型
     * @return
     */
    public Dict getOne(String type) {
        Kv data = Kv.by("type", type);
        SqlPara sqlPara = Db.getSqlPara("sysDict.getOne", data);
        return Dict.dao.findFirst(sqlPara);
    }

    /**
     * 获取系统中树型字典列表数据
     *
     * @return
     */
    public List<Dict> getTreeAll() {
        SqlPara sqlPara = Db.getSqlPara("sysDict.getAll");
        List<Dict> dits = Dict.dao.find(sqlPara);
        return TreeUtils.getJqTreeList(dits);
    }

    /**
     * 查询系统中某个字典是否存在子类字典数据
     *
     * @param parentId
     * @return
     */
    public boolean hasSubList(Long parentId) {
        Kv data = Kv.by("parentId", parentId);
        SqlPara sqlPara = Db.getSqlPara("sysDict.hasSubList", data);
        int rows = Db.queryInt(sqlPara.getSql(), sqlPara.getPara());
        return rows > 0;
    }

    /**
     * 通过主键获取字典的唯一数据
     *
     * @param dictId
     * @return
     */
    public Dict findById(Long dictId) {
        return Dict.dao.findById(dictId);
    }

    /**
     * 新增/修改字典的数据
     *
     * @param dict
     * @return
     */
    public boolean save(Dict dict) {
        String type = StrUtil.nullToDefault(dict.getType(), "").toUpperCase();
        if (Objects.isNull(dict.getId())) {
            dict.setType(type);
            dict.setDeleted(false);
            return dict.save();
        } else {
            Dict entity = findById(dict.getId());
            if (Objects.isNull(entity)) {
                dict.setType(type);
                dict.setDeleted(false);
                return dict.save();
            } else {
                dict.setType(type);
                return dict.update();
            }
        }
    }

    /**
     * 通过主键删除字典的数据
     *
     * @param id
     * @return
     */
    public boolean delById(Long id) {
        Dict dict = new Dict();
        dict.setId(id);
        dict.setDeleted(true);
        return dict.update();
    }
}
